if (typeof Promise !== "undefined" && !Promise.prototype.finally) {
  Promise.prototype.finally = function(callback) {
    const promise = this.constructor;
    return this.then(
      (value) => promise.resolve(callback()).then(() => value),
      (reason) => promise.resolve(callback()).then(() => {
        throw reason;
      })
    );
  };
}
;
if (typeof uni !== "undefined" && uni && uni.requireGlobal) {
  const global = uni.requireGlobal();
  ArrayBuffer = global.ArrayBuffer;
  Int8Array = global.Int8Array;
  Uint8Array = global.Uint8Array;
  Uint8ClampedArray = global.Uint8ClampedArray;
  Int16Array = global.Int16Array;
  Uint16Array = global.Uint16Array;
  Int32Array = global.Int32Array;
  Uint32Array = global.Uint32Array;
  Float32Array = global.Float32Array;
  Float64Array = global.Float64Array;
  BigInt64Array = global.BigInt64Array;
  BigUint64Array = global.BigUint64Array;
}
;
if (uni.restoreGlobal) {
  uni.restoreGlobal(Vue, weex, plus, setTimeout, clearTimeout, setInterval, clearInterval);
}
(function(vue) {
  "use strict";
  function initRuntimeSocket(hosts, port, id) {
    if (hosts == "" || port == "" || id == "")
      return Promise.resolve(null);
    return hosts.split(",").reduce((promise, host) => {
      return promise.then((socket) => {
        if (socket != null)
          return Promise.resolve(socket);
        return tryConnectSocket(host, port, id);
      });
    }, Promise.resolve(null));
  }
  const SOCKET_TIMEOUT = 500;
  function tryConnectSocket(host, port, id) {
    return new Promise((resolve, reject) => {
      const socket = uni.connectSocket({
        url: `ws://${host}:${port}/${id}`,
        multiple: true,
        // 支付宝小程序 是否开启多实例
        fail() {
          resolve(null);
        }
      });
      const timer = setTimeout(() => {
        socket.close({
          code: 1006,
          reason: "connect timeout"
        });
        resolve(null);
      }, SOCKET_TIMEOUT);
      socket.onOpen((e) => {
        clearTimeout(timer);
        resolve(socket);
      });
      socket.onClose((e) => {
        clearTimeout(timer);
        resolve(null);
      });
      socket.onError((e) => {
        clearTimeout(timer);
        resolve(null);
      });
    });
  }
  function formatMessage(type, args) {
    try {
      return {
        type,
        args: formatArgs(args)
      };
    } catch (e) {
    }
    return {
      type,
      args: []
    };
  }
  function formatArgs(args) {
    return args.map((arg) => formatArg(arg));
  }
  function formatArg(arg, depth = 0) {
    if (depth >= 7) {
      return {
        type: "object",
        value: "[Maximum depth reached]"
      };
    }
    const type = typeof arg;
    switch (type) {
      case "string":
        return formatString(arg);
      case "number":
        return formatNumber(arg);
      case "boolean":
        return formatBoolean(arg);
      case "object":
        return formatObject(arg, depth);
      case "undefined":
        return formatUndefined();
      case "function":
        return formatFunction(arg);
      case "symbol": {
        return formatSymbol(arg);
      }
      case "bigint":
        return formatBigInt(arg);
    }
  }
  function formatFunction(value) {
    return {
      type: "function",
      value: `function ${value.name}() {}`
    };
  }
  function formatUndefined() {
    return {
      type: "undefined"
    };
  }
  function formatBoolean(value) {
    return {
      type: "boolean",
      value: String(value)
    };
  }
  function formatNumber(value) {
    return {
      type: "number",
      value: String(value)
    };
  }
  function formatBigInt(value) {
    return {
      type: "bigint",
      value: String(value)
    };
  }
  function formatString(value) {
    return {
      type: "string",
      value
    };
  }
  function formatSymbol(value) {
    return {
      type: "symbol",
      value: value.description
    };
  }
  function formatObject(value, depth) {
    if (value === null) {
      return {
        type: "null"
      };
    }
    {
      if (isComponentPublicInstance(value)) {
        return formatComponentPublicInstance(value, depth);
      }
      if (isComponentInternalInstance(value)) {
        return formatComponentInternalInstance(value, depth);
      }
      if (isUniElement(value)) {
        return formatUniElement(value, depth);
      }
      if (isCSSStyleDeclaration(value)) {
        return formatCSSStyleDeclaration(value, depth);
      }
    }
    if (Array.isArray(value)) {
      return {
        type: "object",
        subType: "array",
        value: {
          properties: value.map((v, i) => formatArrayElement(v, i, depth + 1))
        }
      };
    }
    if (value instanceof Set) {
      return {
        type: "object",
        subType: "set",
        className: "Set",
        description: `Set(${value.size})`,
        value: {
          entries: Array.from(value).map((v) => formatSetEntry(v, depth + 1))
        }
      };
    }
    if (value instanceof Map) {
      return {
        type: "object",
        subType: "map",
        className: "Map",
        description: `Map(${value.size})`,
        value: {
          entries: Array.from(value.entries()).map((v) => formatMapEntry(v, depth + 1))
        }
      };
    }
    if (value instanceof Promise) {
      return {
        type: "object",
        subType: "promise",
        value: {
          properties: []
        }
      };
    }
    if (value instanceof RegExp) {
      return {
        type: "object",
        subType: "regexp",
        value: String(value),
        className: "Regexp"
      };
    }
    if (value instanceof Date) {
      return {
        type: "object",
        subType: "date",
        value: String(value),
        className: "Date"
      };
    }
    if (value instanceof Error) {
      return {
        type: "object",
        subType: "error",
        value: value.message || String(value),
        className: value.name || "Error"
      };
    }
    let className = void 0;
    {
      const constructor = value.constructor;
      if (constructor) {
        if (constructor.get$UTSMetadata$) {
          className = constructor.get$UTSMetadata$().name;
        }
      }
    }
    return {
      type: "object",
      className,
      value: {
        properties: Object.entries(value).map((entry) => formatObjectProperty(entry[0], entry[1], depth + 1))
      }
    };
  }
  function isComponentPublicInstance(value) {
    return value.$ && isComponentInternalInstance(value.$);
  }
  function isComponentInternalInstance(value) {
    return value.type && value.uid != null && value.appContext;
  }
  function formatComponentPublicInstance(value, depth) {
    return {
      type: "object",
      className: "ComponentPublicInstance",
      value: {
        properties: Object.entries(value.$.type).map(([name, value2]) => formatObjectProperty(name, value2, depth + 1))
      }
    };
  }
  function formatComponentInternalInstance(value, depth) {
    return {
      type: "object",
      className: "ComponentInternalInstance",
      value: {
        properties: Object.entries(value.type).map(([name, value2]) => formatObjectProperty(name, value2, depth + 1))
      }
    };
  }
  function isUniElement(value) {
    return value.style && value.tagName != null && value.nodeName != null;
  }
  function formatUniElement(value, depth) {
    return {
      type: "object",
      // 非 x 没有 UniElement 的概念
      // className: 'UniElement',
      value: {
        properties: Object.entries(value).filter(([name]) => [
          "id",
          "tagName",
          "nodeName",
          "dataset",
          "offsetTop",
          "offsetLeft",
          "style"
        ].includes(name)).map(([name, value2]) => formatObjectProperty(name, value2, depth + 1))
      }
    };
  }
  function isCSSStyleDeclaration(value) {
    return typeof value.getPropertyValue === "function" && typeof value.setProperty === "function" && value.$styles;
  }
  function formatCSSStyleDeclaration(style, depth) {
    return {
      type: "object",
      value: {
        properties: Object.entries(style.$styles).map(([name, value]) => formatObjectProperty(name, value, depth + 1))
      }
    };
  }
  function formatObjectProperty(name, value, depth) {
    const result = formatArg(value, depth);
    result.name = name;
    return result;
  }
  function formatArrayElement(value, index, depth) {
    const result = formatArg(value, depth);
    result.name = `${index}`;
    return result;
  }
  function formatSetEntry(value, depth) {
    return {
      value: formatArg(value, depth)
    };
  }
  function formatMapEntry(value, depth) {
    return {
      key: formatArg(value[0], depth),
      value: formatArg(value[1], depth)
    };
  }
  const CONSOLE_TYPES = ["log", "warn", "error", "info", "debug"];
  let sendConsole = null;
  const messageQueue = [];
  const messageExtra = {};
  function sendConsoleMessages(messages) {
    if (sendConsole == null) {
      messageQueue.push(...messages);
      return;
    }
    sendConsole(JSON.stringify(Object.assign({
      type: "console",
      data: messages
    }, messageExtra)));
  }
  function setSendConsole(value, extra = {}) {
    sendConsole = value;
    Object.assign(messageExtra, extra);
    if (value != null && messageQueue.length > 0) {
      const messages = messageQueue.slice();
      messageQueue.length = 0;
      sendConsoleMessages(messages);
    }
  }
  const originalConsole = /* @__PURE__ */ CONSOLE_TYPES.reduce((methods, type) => {
    methods[type] = console[type].bind(console);
    return methods;
  }, {});
  function rewriteConsole() {
    function wrapConsole(type) {
      return function(...args) {
        [...args];
        sendConsoleMessages([formatMessage(type, args)]);
      };
    }
    if (isConsoleWritable()) {
      CONSOLE_TYPES.forEach((type) => {
        console[type] = wrapConsole(type);
      });
      return function restoreConsole() {
        CONSOLE_TYPES.forEach((type) => {
          console[type] = originalConsole[type];
        });
      };
    } else {
      {
        if (typeof uni !== "undefined" && uni.__f__) {
          const oldLog = uni.__f__;
          if (oldLog) {
            uni.__f__ = function(...args) {
              const [type, filename, ...rest] = args;
              oldLog(type, "", ...rest);
              sendConsoleMessages([formatMessage(type, [...rest, filename])]);
            };
            return function restoreConsole() {
              uni.__f__ = oldLog;
            };
          }
        }
      }
    }
    return function restoreConsole() {
    };
  }
  function isConsoleWritable() {
    const value = console.log;
    const sym = Symbol();
    try {
      console.log = sym;
    } catch (ex) {
      return false;
    }
    const isWritable = console.log === sym;
    console.log = value;
    return isWritable;
  }
  let sendError = null;
  const errorQueue = /* @__PURE__ */ new Set();
  const errorExtra = {};
  function sendErrorMessages(errors) {
    if (sendError == null) {
      errors.forEach((error) => {
        errorQueue.add(error);
      });
      return;
    }
    const data = errors.map((err) => {
      const isPromiseRejection = err && "promise" in err && "reason" in err;
      const prefix = isPromiseRejection ? "UnhandledPromiseRejection: " : "";
      if (isPromiseRejection) {
        err = err.reason;
      }
      if (err instanceof Error && err.stack) {
        if (err.message && !err.stack.includes(err.message)) {
          return `${prefix}${err.message}
${err.stack}`;
        }
        return `${prefix}${err.stack}`;
      }
      if (typeof err === "object" && err !== null) {
        try {
          return prefix + JSON.stringify(err);
        } catch (err2) {
          return prefix + String(err2);
        }
      }
      return prefix + String(err);
    }).filter(Boolean);
    if (data.length > 0) {
      sendError(JSON.stringify(Object.assign({
        type: "error",
        data
      }, errorExtra)));
    }
  }
  function setSendError(value, extra = {}) {
    sendError = value;
    Object.assign(errorExtra, extra);
    if (value != null && errorQueue.size > 0) {
      const errors = Array.from(errorQueue);
      errorQueue.clear();
      sendErrorMessages(errors);
    }
  }
  function initOnError() {
    function onError(error) {
      try {
        if (typeof PromiseRejectionEvent !== "undefined" && error instanceof PromiseRejectionEvent && error.reason instanceof Error && error.reason.message && error.reason.message.includes(`Cannot create property 'errMsg' on string 'taskId`)) {
          return;
        }
        if (false)
          ;
        sendErrorMessages([error]);
      } catch (err) {
        originalConsole.error(err);
      }
    }
    if (typeof uni.onError === "function") {
      uni.onError(onError);
    }
    if (typeof uni.onUnhandledRejection === "function") {
      uni.onUnhandledRejection(onError);
    }
    return function offError() {
      if (typeof uni.offError === "function") {
        uni.offError(onError);
      }
      if (typeof uni.offUnhandledRejection === "function") {
        uni.offUnhandledRejection(onError);
      }
    };
  }
  function initRuntimeSocketService() {
    const hosts = "127.0.0.1,192.168.1.3,169.254.135.244";
    const port = "8090";
    const id = "app-harmony_bbUCXZ";
    const lazy = typeof swan !== "undefined";
    let restoreError = lazy ? () => {
    } : initOnError();
    let restoreConsole = lazy ? () => {
    } : rewriteConsole();
    return Promise.resolve().then(() => {
      if (lazy) {
        restoreError = initOnError();
        restoreConsole = rewriteConsole();
      }
      return initRuntimeSocket(hosts, port, id).then((socket) => {
        if (!socket) {
          restoreError();
          restoreConsole();
          originalConsole.error(wrapError("开发模式下日志通道建立 socket 连接失败。"));
          originalConsole.error(wrapError("如果是小程序平台，请勾选不校验合法域名配置。"));
          originalConsole.error(wrapError("如果是运行到真机，请确认手机与电脑处于同一网络。"));
          return false;
        }
        initMiniProgramGlobalFlag();
        socket.onClose(() => {
          originalConsole.error(wrapError("开发模式下日志通道 socket 连接关闭，请在 HBuilderX 中重新运行。"));
          restoreError();
          restoreConsole();
        });
        setSendConsole((data) => {
          socket.send({
            data
          });
        });
        setSendError((data) => {
          socket.send({
            data
          });
        });
        return true;
      });
    });
  }
  const ERROR_CHAR = "‌";
  function wrapError(error) {
    return `${ERROR_CHAR}${error}${ERROR_CHAR}`;
  }
  function initMiniProgramGlobalFlag() {
    if (typeof wx !== "undefined") {
      wx.__uni_console__ = true;
    } else if (typeof my !== "undefined") {
      my.__uni_console__ = true;
    } else if (typeof tt !== "undefined") {
      tt.__uni_console__ = true;
    } else if (typeof swan !== "undefined") {
      swan.__uni_console__ = true;
    } else if (typeof qq !== "undefined") {
      qq.__uni_console__ = true;
    } else if (typeof ks !== "undefined") {
      ks.__uni_console__ = true;
    } else if (typeof jd !== "undefined") {
      jd.__uni_console__ = true;
    } else if (typeof xhs !== "undefined") {
      xhs.__uni_console__ = true;
    } else if (typeof has !== "undefined") {
      has.__uni_console__ = true;
    } else if (typeof qa !== "undefined") {
      qa.__uni_console__ = true;
    }
  }
  initRuntimeSocketService();
  function formatAppLog(type, filename, ...args) {
    if (uni.__log__) {
      uni.__log__(type, filename, ...args);
    } else {
      console[type].apply(console, [...args, filename]);
    }
  }
  const _export_sfc = (sfc, props) => {
    const target = sfc.__vccOpts || sfc;
    for (const [key, val] of props) {
      target[key] = val;
    }
    return target;
  };
  const _sfc_main$1 = {
    data() {
      return {
        ipAddress: "",
        locationInfo: null,
        apiKey: "f06b73555ca5f57d2af8aa5be8599a25",
        isLoading: false,
        historyList: [],
        showHistory: false,
        systemInfo: {
          platform: "",
          system: "",
          version: "",
          brand: "",
          language: "",
          networkType: ""
        },
        currentTime: ""
      };
    },
    created() {
      this.initSystemInfo();
      this.startTimeUpdate();
      this.loadHistoryFromStorage();
    },
    methods: {
      initSystemInfo() {
        const info = uni.getSystemInfoSync();
        this.systemInfo = {
          platform: info.platform,
          system: info.system,
          version: info.version,
          brand: info.brand,
          language: info.language,
          networkType: info.networkType || "获取中..."
        };
        uni.getNetworkType({
          success: (res) => {
            this.systemInfo.networkType = res.networkType;
          }
        });
      },
      startTimeUpdate() {
        const updateTime = () => {
          this.currentTime = (/* @__PURE__ */ new Date()).toLocaleString();
        };
        updateTime();
        setInterval(updateTime, 1e3);
      },
      loadHistoryFromStorage() {
        try {
          const history = uni.getStorageSync("ipLocationHistory");
          if (history) {
            this.historyList = history;
          }
        } catch (e) {
          formatAppLog("error", "at pages/index/index.vue:149", "读取历史记录失败:", e);
        }
      },
      loadHistoryItem(item) {
        this.ipAddress = item.ip;
        this.locationInfo = item;
      },
      validateIP(ip) {
        if (!ip)
          return true;
        const pattern = /^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
        return pattern.test(ip);
      },
      async getLocation() {
        const queryIP = this.ipAddress || "61.178.51.181";
        if (queryIP && !this.validateIP(queryIP)) {
          uni.showToast({
            title: "IP地址格式不正确",
            icon: "none"
          });
          return;
        }
        this.isLoading = true;
        try {
          formatAppLog("log", "at pages/index/index.vue:173", "开始获取位置信息", `IP地址: ${queryIP}`);
          const url = `https://restapi.amap.com/v3/ip?key=${this.apiKey}&ip=${queryIP}`;
          formatAppLog("log", "at pages/index/index.vue:175", "请求URL:", url);
          const response = await uni.request({
            url,
            method: "GET",
            timeout: 1e4
          });
          formatAppLog("log", "at pages/index/index.vue:182", "API响应数据:", response.data);
          if (response.data.status === "1") {
            this.locationInfo = response.data;
            const historyItem = {
              ip: this.ipAddress,
              ...response.data,
              timestamp: (/* @__PURE__ */ new Date()).getTime()
            };
            this.historyList.unshift(historyItem);
            if (this.historyList.length > 10) {
              this.historyList.pop();
            }
            uni.setStorageSync("ipLocationHistory", this.historyList);
            formatAppLog("log", "at pages/index/index.vue:197", "位置信息获取成功:", {
              省份: response.data.province,
              城市: response.data.city,
              区域编码: response.data.adcode,
              经纬度范围: response.data.rectangle
            });
          } else {
            const errorMsg = response.data.info || "获取位置信息失败";
            formatAppLog("warn", "at pages/index/index.vue:205", "位置信息获取失败:", errorMsg);
            uni.showToast({
              title: errorMsg,
              icon: "none"
            });
          }
        } catch (error) {
          formatAppLog("error", "at pages/index/index.vue:212", "网络请求异常:", error);
          uni.showToast({
            title: "网络请求失败",
            icon: "none"
          });
        } finally {
          this.isLoading = false;
        }
      }
    }
  };
  function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
    return vue.openBlock(), vue.createElementBlock("view", { class: "content" }, [
      vue.createElementVNode("view", { class: "input-area" }, [
        vue.withDirectives(vue.createElementVNode("input", {
          type: "text",
          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => $data.ipAddress = $event),
          placeholder: "请输入IP地址（可选）",
          class: "ip-input",
          disabled: $data.isLoading
        }, null, 8, ["disabled"]), [
          [vue.vModelText, $data.ipAddress]
        ]),
        vue.createElementVNode("button", {
          onClick: _cache[1] || (_cache[1] = (...args) => $options.getLocation && $options.getLocation(...args)),
          class: "search-btn",
          disabled: $data.isLoading
        }, [
          !$data.isLoading ? (vue.openBlock(), vue.createElementBlock("text", { key: 0 }, "获取位置")) : (vue.openBlock(), vue.createElementBlock("text", { key: 1 }, "查询中..."))
        ], 8, ["disabled"])
      ]),
      vue.createElementVNode("view", { class: "system-info" }, [
        vue.createElementVNode("view", { class: "info-item" }, [
          vue.createElementVNode("text", { class: "label" }, "平台："),
          vue.createElementVNode(
            "text",
            { class: "value" },
            vue.toDisplayString($data.systemInfo.platform),
            1
            /* TEXT */
          )
        ]),
        vue.createElementVNode("view", { class: "info-item" }, [
          vue.createElementVNode("text", { class: "label" }, "系统："),
          vue.createElementVNode(
            "text",
            { class: "value" },
            vue.toDisplayString($data.systemInfo.system),
            1
            /* TEXT */
          )
        ]),
        vue.createElementVNode("view", { class: "info-item" }, [
          vue.createElementVNode("text", { class: "label" }, "版本："),
          vue.createElementVNode(
            "text",
            { class: "value" },
            vue.toDisplayString($data.systemInfo.version),
            1
            /* TEXT */
          )
        ]),
        vue.createElementVNode("view", { class: "info-item" }, [
          vue.createElementVNode("text", { class: "label" }, "品牌："),
          vue.createElementVNode(
            "text",
            { class: "value" },
            vue.toDisplayString($data.systemInfo.brand),
            1
            /* TEXT */
          )
        ]),
        vue.createElementVNode("view", { class: "info-item" }, [
          vue.createElementVNode("text", { class: "label" }, "语言："),
          vue.createElementVNode(
            "text",
            { class: "value" },
            vue.toDisplayString($data.systemInfo.language),
            1
            /* TEXT */
          )
        ]),
        vue.createElementVNode("view", { class: "info-item" }, [
          vue.createElementVNode("text", { class: "label" }, "网络类型："),
          vue.createElementVNode(
            "text",
            { class: "value" },
            vue.toDisplayString($data.systemInfo.networkType),
            1
            /* TEXT */
          )
        ]),
        vue.createElementVNode("view", { class: "info-item" }, [
          vue.createElementVNode("text", { class: "label" }, "当前时间："),
          vue.createElementVNode(
            "text",
            { class: "value" },
            vue.toDisplayString($data.currentTime),
            1
            /* TEXT */
          )
        ])
      ]),
      vue.createElementVNode("view", {
        class: "history-toggle",
        onClick: _cache[2] || (_cache[2] = ($event) => $data.showHistory = !$data.showHistory)
      }, [
        vue.createElementVNode("text", null, "历史记录"),
        vue.createElementVNode(
          "text",
          { class: "toggle-icon" },
          vue.toDisplayString($data.showHistory ? "▼" : "▶"),
          1
          /* TEXT */
        )
      ]),
      $data.showHistory && $data.historyList.length > 0 ? (vue.openBlock(), vue.createElementBlock("view", {
        key: 0,
        class: "history-list"
      }, [
        (vue.openBlock(true), vue.createElementBlock(
          vue.Fragment,
          null,
          vue.renderList($data.historyList, (item, index) => {
            return vue.openBlock(), vue.createElementBlock("view", {
              key: index,
              class: "history-item",
              onClick: ($event) => $options.loadHistoryItem(item)
            }, [
              vue.createElementVNode(
                "text",
                { class: "history-ip" },
                vue.toDisplayString(item.ip || "当前IP"),
                1
                /* TEXT */
              ),
              vue.createElementVNode(
                "text",
                { class: "history-location" },
                vue.toDisplayString(item.province) + " " + vue.toDisplayString(item.city),
                1
                /* TEXT */
              )
            ], 8, ["onClick"]);
          }),
          128
          /* KEYED_FRAGMENT */
        ))
      ])) : vue.createCommentVNode("v-if", true),
      $data.locationInfo ? (vue.openBlock(), vue.createElementBlock("view", {
        key: 1,
        class: "result-area"
      }, [
        vue.createElementVNode("view", { class: "info-item" }, [
          vue.createElementVNode("text", { class: "label" }, "省份："),
          vue.createElementVNode(
            "text",
            { class: "value" },
            vue.toDisplayString($data.locationInfo.province),
            1
            /* TEXT */
          )
        ]),
        vue.createElementVNode("view", { class: "info-item" }, [
          vue.createElementVNode("text", { class: "label" }, "城市："),
          vue.createElementVNode(
            "text",
            { class: "value" },
            vue.toDisplayString($data.locationInfo.city),
            1
            /* TEXT */
          )
        ]),
        vue.createElementVNode("view", { class: "info-item" }, [
          vue.createElementVNode("text", { class: "label" }, "区域编码："),
          vue.createElementVNode(
            "text",
            { class: "value" },
            vue.toDisplayString($data.locationInfo.adcode),
            1
            /* TEXT */
          )
        ]),
        vue.createElementVNode("view", { class: "info-item" }, [
          vue.createElementVNode("text", { class: "label" }, "经纬度范围："),
          vue.createElementVNode(
            "text",
            { class: "value" },
            vue.toDisplayString($data.locationInfo.rectangle),
            1
            /* TEXT */
          )
        ])
      ])) : vue.createCommentVNode("v-if", true),
      vue.createElementVNode("view", { class: "copyright-area" }, [
        vue.createElementVNode("view", { class: "copyright-card" }, [
          vue.createElementVNode("view", { class: "copyright-item" }, [
            vue.createElementVNode("text", { class: "copyright-label" }, "作者："),
            vue.createElementVNode("text", { class: "copyright-value" }, "坚果派")
          ]),
          vue.createElementVNode("view", { class: "copyright-item" }, [
            vue.createElementVNode("text", { class: "copyright-label" }, "公众号："),
            vue.createElementVNode("text", { class: "copyright-value" }, "nutpi")
          ]),
          vue.createElementVNode("view", { class: "copyright-item" }, [
            vue.createElementVNode("text", { class: "copyright-label" }, "电话："),
            vue.createElementVNode("text", { class: "copyright-value" }, "17752170152")
          ]),
          vue.createElementVNode("view", { class: "copyright-item" }, [
            vue.createElementVNode("text", { class: "copyright-label" }, "官网："),
            vue.createElementVNode("text", { class: "copyright-value" }, "https://www.nutpi.net/")
          ])
        ])
      ])
    ]);
  }
  const PagesIndexIndex = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", _sfc_render], ["__file", "/Users/jianguo/Desktop/teaching/uni_ip_location/pages/index/index.vue"]]);
  __definePage("pages/index/index", PagesIndexIndex);
  const _sfc_main = {
    onLaunch: function() {
      formatAppLog("log", "at App.vue:4", "应用启动 (App Launch)", {
        平台: uni.getSystemInfoSync().platform,
        系统: uni.getSystemInfoSync().system,
        版本: uni.getSystemInfoSync().version,
        品牌: uni.getSystemInfoSync().brand,
        语言: uni.getSystemInfoSync().language
      });
    },
    onShow: function() {
      formatAppLog("log", "at App.vue:13", "应用进入前台 (App Show)", {
        时间: (/* @__PURE__ */ new Date()).toLocaleString(),
        网络类型: uni.getSystemInfoSync().networkType
      });
    },
    onHide: function() {
      formatAppLog("log", "at App.vue:19", "应用进入后台 (App Hide)", {
        时间: (/* @__PURE__ */ new Date()).toLocaleString()
      });
    }
  };
  const App = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "/Users/jianguo/Desktop/teaching/uni_ip_location/App.vue"]]);
  function createApp() {
    const app = vue.createVueApp(App);
    return {
      app
    };
  }
  const { app: __app__, Vuex: __Vuex__, Pinia: __Pinia__ } = createApp();
  uni.Vuex = __Vuex__;
  uni.Pinia = __Pinia__;
  __app__.provide("__globalStyles", __uniConfig.styles);
  __app__._component.mpType = "app";
  __app__._component.render = () => {
  };
  __app__.mount("#app");
})(Vue);
